\hypertarget{class_solver}{
\section{Solver Class Reference}
\label{class_solver}\index{Solver@{Solver}}
}


creates fluid particles and perform SPH fluid simulation at every iteration  




{\ttfamily \#include $<$Solver.h$>$}



Collaboration diagram for Solver:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[height=600pt]{class_solver__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{DoxyCompactItemize}
\item 
\hyperlink{class_solver_a9dfe7ae9ce617e8a6398be34284c907a}{Solver} ()
\begin{DoxyCompactList}\small\item\em ctor \end{DoxyCompactList}\item 
\hyperlink{class_solver_aba52d3c92fafceb6fe39f937f2d73db3}{$\sim$Solver} ()
\begin{DoxyCompactList}\small\item\em dtor \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a445201a1ac13e8e855cd74945602f69f}{updateFluid} (\hyperlink{class_environment}{Environment} $\ast$io\_\-environment, \hyperlink{class_integration}{Integration} $\ast$\_\-integration)
\begin{DoxyCompactList}\small\item\em update the fluid state at each timestep interval \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a693fcda57de13884c032ef7503dc3151}{initialiseDrawing} ()
\begin{DoxyCompactList}\small\item\em initialise opengl drawing \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a0d31c43c6e8e4acff7556e4410043073}{render} (ngl::TransformStack \_\-txStack, \hyperlink{class_shader_library}{ShaderLibrary} $\ast$io\_\-sman, const std::string \_\-shader)
\begin{DoxyCompactList}\small\item\em display the particle spheres \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a2672537c98f708e8971fd5cf151035cd}{injectParticles} ()
\begin{DoxyCompactList}\small\item\em inject/pumps in hose particles into the simulation \end{DoxyCompactList}\item 
std::vector$<$ std::vector$<$ ngl::Vector $>$ $>$ \hyperlink{class_solver_a738ef3a108a4c128bb860a08c4d5f85b}{getPositionList} ()
\begin{DoxyCompactList}\small\item\em return a 2d list of the position of particles, used for caching \end{DoxyCompactList}\item 
std::vector$<$ std::string $>$ \hyperlink{class_solver_a4673b7a59a2cceddb90f4553f96c526f}{getNameList} ()
\begin{DoxyCompactList}\small\item\em return the list of fluid names, used for caching \end{DoxyCompactList}\item 
void \hyperlink{class_solver_abb5641e50e11d98e800f0018248849c9}{toggleNextHoseableFluid} ()
\begin{DoxyCompactList}\small\item\em toggle between the fluids to determine which one will be used by the hose \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a826574de203172353c534f231db268c0}{setCurrentHoseableFluid} (const int \_\-v)
\begin{DoxyCompactList}\small\item\em set the current hoseable fluid id \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_a0961417399ac099b06754f8fad70546d}{getEnableAutoFluidUpdate} () const 
\begin{DoxyCompactList}\small\item\em returns wherether automatic fluid update is enabled \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a73637ce7688c9507abb31c09665d3237}{toggleEnableAutoFluidUpdate} ()
\begin{DoxyCompactList}\small\item\em toggles the state of the automatic fluid update flag \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_a8b117559b2b80d11a9f9dc3752246c06}{getSmoothingLength} () const 
\begin{DoxyCompactList}\small\item\em return the smoothing length of the neighbour search \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_a8bf3d31cfd0cb5cff2dcffdd58f810c7}{getDrawHoseMarker} () const 
\begin{DoxyCompactList}\small\item\em return the flag of whether to draw hose marker \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_a644510478bf31e777f1c819dcd6ecb98}{getHoseCenter} () const 
\begin{DoxyCompactList}\small\item\em return the centre of the hose \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_a7e02195cbbe42c28c21462ab9a715be9}{getHoseVelocity} () const 
\begin{DoxyCompactList}\small\item\em return the velocity of the hose \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_a66eabb386a77b32a57b27dfda72390a0}{getHoseWaitUntilHitBoundary} () const 
\begin{DoxyCompactList}\small\item\em return whether the hose particles wait until they first hit the boundary before they act as fluid \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_a44222e716998ab995593ad7a8e2ccef8}{getHoseWaitUntilHitRBD} () const 
\begin{DoxyCompactList}\small\item\em toggles whether the hose particles wait until they first hit RBDs before they act as fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a23736b6b761b1d553ee320f5b64c8e52}{setHoseWaitUntilHitBoundary} (const bool \_\-v)
\begin{DoxyCompactList}\small\item\em set whether the hose particles wait until they first hit the boundary before they act as fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_ac1600f3c384f56ec0a83bd3a25a38cd1}{setHoseWaitUntilHitRBD} (const bool \_\-v)
\begin{DoxyCompactList}\small\item\em set whether the hose particles wait until they first hit RBDs before they act as fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a27ff860a5d81e7fe1f89d9bd020ccd7c}{setDrawHoseMarker} (const bool \_\-v)
\begin{DoxyCompactList}\small\item\em set flag of whether to draw hose marker \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a592a9c837eb3409ebcb9cf4a61d4c5fa}{setHoseCenter} (const ngl::Vector \_\-v)
\begin{DoxyCompactList}\small\item\em set the centre of the hose \end{DoxyCompactList}\item 
void \hyperlink{class_solver_ab7bc3f274693f9395cbbc7eb9d255cda}{setHoseVelocity} (const ngl::Vector \_\-v)
\begin{DoxyCompactList}\small\item\em return the velocity of the hose \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a3aa03b6f3e032453ddf8c8e54fb227ec}{setSmoothingLength} (const ngl::Real \_\-v)
\begin{DoxyCompactList}\small\item\em set the smoothing kernel length \end{DoxyCompactList}\item 
std::vector$<$ \hyperlink{class_fluid_particle}{FluidParticle} $>$ \hyperlink{class_solver_a86102cbc9dd46497658f981ef78dc827}{getHoseParticlePrototypeList} () const 
\begin{DoxyCompactList}\small\item\em return the list of fluid prototypes \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a8f46937e18acd18807b3c10805c37212}{updateRestDensityForFluid} (const int \_\-fluidId, const ngl::Real \_\-restDensity)
\begin{DoxyCompactList}\small\item\em update rest density of a fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a731102ccd50860362b79e39357b5354b}{updateGasConstantForFluid} (const int \_\-fluidId, const ngl::Real \_\-gasConstant)
\begin{DoxyCompactList}\small\item\em update gas constant of a fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_afd8b0440fbd7c0e5a95098b250a5b5c4}{updateViscosityConstantForFluid} (const int \_\-fluidId, const ngl::Real \_\-viscosityConstant)
\begin{DoxyCompactList}\small\item\em update viscosity constant of a fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a2ed2b6ce87013e8ed55abbc1ca3a05b6}{updateSurfaceCoefficientForFluid} (const int \_\-fluidId, const ngl::Real \_\-coefficient)
\begin{DoxyCompactList}\small\item\em update surface coefficient of a fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a56927b0f0d5365b8b85c087acbf342c2}{updateSurfaceThresholdForFluid} (const int \_\-fluidId, const ngl::Real \_\-threshold)
\begin{DoxyCompactList}\small\item\em update surface threshold of a fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_aeabd083481cb2e33014cd7d0bb8129a0}{updateInterfaceCoefficientForFluid} (const int \_\-fluidId, const ngl::Real \_\-coefficient)
\begin{DoxyCompactList}\small\item\em update interface coefficient of a fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a4ce3c2b6ab7a8ea665f53dd364428c40}{updateInterfaceThresholdForFluid} (const int \_\-fluidId, const ngl::Real \_\-threshold)
\begin{DoxyCompactList}\small\item\em update interface threshold of a fluid \end{DoxyCompactList}\item 
void \hyperlink{class_solver_a8195de06f78ee8f4778e8528be93611b}{updateInterfaceColorForFluid} (const int \_\-fluidId, const ngl::Real \_\-color)
\begin{DoxyCompactList}\small\item\em update interface color of a fluid \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Private Member Functions}
\begin{DoxyCompactItemize}
\item 
ngl::Real \hyperlink{class_solver_aaa73637a35872bb7aa1883728e9da51f}{WKernel\_\-Poly} (const ngl::Real \_\-separationLength)
\begin{DoxyCompactList}\small\item\em calculate the poly 6 kernel \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_a5462e249d35a3467864f449db410a626}{WKernel\_\-Poly\_\-Gradient} (const ngl::Vector \_\-separationVector)
\begin{DoxyCompactList}\small\item\em calculate the poly 6 gradient kernel \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_a22bdb89c711ffe08811065684680cc8a}{WKernel\_\-Poly\_\-Laplacian} (const ngl::Real \_\-separationLength)
\begin{DoxyCompactList}\small\item\em calculate the poly 6 laplacian kernel \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_ac17f6ca35c9d92ea29d625dad841f917}{WKernel\_\-Pressure\_\-Gradient} (const ngl::Vector \_\-separationVector)
\begin{DoxyCompactList}\small\item\em calculate the pressure (spiky) gradient kernel \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_a2c0079b0c5d1f74e9fdbbd59b6df4ee7}{WKernel\_\-Viscosity\_\-Laplacian} (const ngl::Real \_\-separationLength)
\begin{DoxyCompactList}\small\item\em calculate the viscosity laplacian kernel \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_a62a6ace7a8ff2e18dd6e2b6475b4912c}{normalise} (const ngl::Vector \_\-vector)
\begin{DoxyCompactList}\small\item\em normalise a vector \end{DoxyCompactList}\item 
int \hyperlink{class_solver_afa3aa866448665b98b9868ae43ac5eab}{getFluidIdFromName} (const std::string \_\-name)
\begin{DoxyCompactList}\small\item\em get a particle fluid id from its name \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Private Attributes}
\begin{DoxyCompactItemize}
\item 
std::vector$<$ \hyperlink{class_fluid_particle}{FluidParticle} $>$ \hyperlink{class_solver_aff683c36e82c4b0afd62454a028c4b36}{m\_\-particleList}
\begin{DoxyCompactList}\small\item\em list of particles making up the fluid simulation \end{DoxyCompactList}\item 
std::vector$<$ \hyperlink{_solver_8h_a0f928bf0f1e48e423cc92f38b3add3c3}{ParticleVector} $>$ \hyperlink{class_solver_a769da38bdac0dfafcb2c82cef143e30b}{m\_\-neighbourForParticleList}
\begin{DoxyCompactList}\small\item\em the big list of neighbours of each particle \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_a0b1cb8a50f3a6e98bdb6144d2fead558}{m\_\-smoothingLength}
\begin{DoxyCompactList}\small\item\em smoothing kernel length \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_a26446ff6dafc53811a1fce955b2f80a6}{m\_\-enableAutoFluid}
\begin{DoxyCompactList}\small\item\em flag to control automatic movement of the fluid \end{DoxyCompactList}\item 
\hyperlink{class_neighbour}{Neighbour} $\ast$ \hyperlink{class_solver_a6b609b8c74a005f387fadfd748648a2f}{m\_\-neighbour}
\begin{DoxyCompactList}\small\item\em the neighbouring structure for the fluid particles \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_ac4766e973ca7e0a94836ef19a2dc0ed1}{m\_\-weightPoly}
\begin{DoxyCompactList}\small\item\em pre-\/calculated part of the poly 6 kernel \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_a54a080a7d0fcaa85402c731e9204bdb6}{m\_\-weightPolyGradient}
\begin{DoxyCompactList}\small\item\em pre-\/calculated part of the poly 6 gradient kernel \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_afd4ec059a18e5a3add5104fa5d12f42f}{m\_\-weightPolyLaplacian}
\begin{DoxyCompactList}\small\item\em pre-\/calculated part of the poly 6 laplacian kernel \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_a2ac1b25eb8ff28691f84fe5a0503c48d}{m\_\-weightPressureGradient}
\begin{DoxyCompactList}\small\item\em pre-\/calculated part of the pressure gradient kernel \end{DoxyCompactList}\item 
ngl::Real \hyperlink{class_solver_a6c7b46d2a19825efe09f863aec3ed557}{m\_\-weightViscosityLaplacian}
\begin{DoxyCompactList}\small\item\em pre-\/calculated part of the viscosity laplacian kernel \end{DoxyCompactList}\item 
std::vector$<$ \hyperlink{class_fluid_particle}{FluidParticle} $>$ \hyperlink{class_solver_a1f6ecbfa472517ff8bb60259dc0bfca7}{m\_\-hoseParticlePrototypeList}
\begin{DoxyCompactList}\small\item\em list of particles, one per fluid that is used as a prototype when creating a hose \end{DoxyCompactList}\item 
std::vector$<$ \hyperlink{class_fluid_particle}{FluidParticle} $>$ \hyperlink{class_solver_a947b8362701a0de9f3d61187c71b003f}{m\_\-hoseParticleList}
\begin{DoxyCompactList}\small\item\em list of particles making up the hose model \end{DoxyCompactList}\item 
int \hyperlink{class_solver_a9ed412b05483c23c1662cace6c2fa655}{m\_\-currentHoseableFluid}
\begin{DoxyCompactList}\small\item\em the current fluid id that is injected when hose is applied \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_ac2d094ff22778ae503a267db3e861664}{m\_\-hoseInitialCenter}
\begin{DoxyCompactList}\small\item\em the initial position of the hose particles \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_a005d898e17088db5cb2694c597017359}{m\_\-hoseCenter}
\begin{DoxyCompactList}\small\item\em the current position where hose particles are injected into the scene \end{DoxyCompactList}\item 
ngl::Vector \hyperlink{class_solver_acbba3aebcf71f5c2edd68be50bf0650c}{m\_\-hoseVelocity}
\begin{DoxyCompactList}\small\item\em the velocity of hose particles \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_ac20b1359d36c008204e912930cf63f16}{m\_\-drawHoseMarker}
\begin{DoxyCompactList}\small\item\em toggles whether to draw hose marker \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_a3679a1060fbf7c40c64abc54317408af}{m\_\-hoseWaitUntilHitBoundary}
\begin{DoxyCompactList}\small\item\em toggles whether the hose particles wait until they first hit the boundary before they act as fluid \end{DoxyCompactList}\item 
bool \hyperlink{class_solver_a478175bd6c13dacb3599b77eb88dd723}{m\_\-hoseWaitUntilHitRBD}
\begin{DoxyCompactList}\small\item\em toggles whether the hose particles wait until they first hit RBDs before they act as fluid \end{DoxyCompactList}\item 
int \hyperlink{class_solver_aa2af6362795eeca8486bf47bdae85cdb}{m\_\-iteration}
\begin{DoxyCompactList}\small\item\em iteration counter \end{DoxyCompactList}\end{DoxyCompactItemize}


\subsection{Detailed Description}
creates fluid particles and perform SPH fluid simulation at every iteration 

Definition at line 27 of file Solver.h.



\subsection{Constructor \& Destructor Documentation}
\hypertarget{class_solver_a9dfe7ae9ce617e8a6398be34284c907a}{
\index{Solver@{Solver}!Solver@{Solver}}
\index{Solver@{Solver}!Solver@{Solver}}
\subsubsection[{Solver}]{\setlength{\rightskip}{0pt plus 5cm}Solver::Solver (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_solver_a9dfe7ae9ce617e8a6398be34284c907a}


ctor 



Definition at line 12 of file Solver.cpp.



References Configuration::initialiseFluidSolver(), m\_\-currentHoseableFluid, m\_\-drawHoseMarker, m\_\-enableAutoFluid, m\_\-hoseCenter, m\_\-hoseParticleList, m\_\-hoseParticlePrototypeList, m\_\-hoseVelocity, m\_\-hoseWaitUntilHitBoundary, m\_\-hoseWaitUntilHitRBD, m\_\-iteration, m\_\-neighbour, m\_\-particleList, m\_\-smoothingLength, m\_\-weightPoly, m\_\-weightPolyGradient, m\_\-weightPolyLaplacian, m\_\-weightPressureGradient, and m\_\-weightViscosityLaplacian.


\begin{DoxyCode}
{
    //create particles and initialise parameters
    Configuration::initialiseFluidSolver
            (
                m_smoothingLength,
                m_particleList,
                m_hoseParticlePrototypeList,
                m_hoseParticleList,
                m_hoseCenter,
                m_hoseVelocity,
                m_drawHoseMarker,
                m_hoseWaitUntilHitBoundary,
                m_hoseWaitUntilHitRBD
           );

    //precompute kernel weight multipliers
    m_weightPoly = (315.0 / (64.0 * ngl::PI * pow(m_smoothingLength, 9)));
    m_weightPolyGradient = (-945.0 / (32.0 * ngl::PI * pow(m_smoothingLength, 9))
      );
    m_weightPolyLaplacian = (-945.0 / (32.0 * ngl::PI * pow(m_smoothingLength, 9)
      ));
    m_weightPressureGradient = (-45.0 / (ngl::PI * pow(m_smoothingLength, 6)));
    m_weightViscosityLaplacian = (45.0 / (ngl::PI * pow(m_smoothingLength, 6)));

    //initialise parameters
    m_enableAutoFluid = true;
    m_currentHoseableFluid = 0;

    //create neighbouring structure
    m_neighbour = new Neighbour(m_particleList.size(), m_smoothingLength);

    m_iteration = 0;
}
\end{DoxyCode}


Here is the call graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=354pt]{class_solver_a9dfe7ae9ce617e8a6398be34284c907a_cgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_aba52d3c92fafceb6fe39f937f2d73db3}{
\index{Solver@{Solver}!$\sim$Solver@{$\sim$Solver}}
\index{$\sim$Solver@{$\sim$Solver}!Solver@{Solver}}
\subsubsection[{$\sim$Solver}]{\setlength{\rightskip}{0pt plus 5cm}Solver::$\sim$Solver (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_solver_aba52d3c92fafceb6fe39f937f2d73db3}


dtor 



Definition at line 45 of file Solver.cpp.



References m\_\-neighbour.


\begin{DoxyCode}
{
    //clean up
    std::cout << "Fluid Solver Cleanup" << std::endl;

    //delete objects
    delete m_neighbour;
}
\end{DoxyCode}


\subsection{Member Function Documentation}
\hypertarget{class_solver_a8bf3d31cfd0cb5cff2dcffdd58f810c7}{
\index{Solver@{Solver}!getDrawHoseMarker@{getDrawHoseMarker}}
\index{getDrawHoseMarker@{getDrawHoseMarker}!Solver@{Solver}}
\subsubsection[{getDrawHoseMarker}]{\setlength{\rightskip}{0pt plus 5cm}bool Solver::getDrawHoseMarker (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a8bf3d31cfd0cb5cff2dcffdd58f810c7}


return the flag of whether to draw hose marker 



Definition at line 89 of file Solver.h.



References m\_\-drawHoseMarker.


\begin{DoxyCode}
{ return m_drawHoseMarker; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=394pt]{class_solver_a8bf3d31cfd0cb5cff2dcffdd58f810c7_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a0961417399ac099b06754f8fad70546d}{
\index{Solver@{Solver}!getEnableAutoFluidUpdate@{getEnableAutoFluidUpdate}}
\index{getEnableAutoFluidUpdate@{getEnableAutoFluidUpdate}!Solver@{Solver}}
\subsubsection[{getEnableAutoFluidUpdate}]{\setlength{\rightskip}{0pt plus 5cm}bool Solver::getEnableAutoFluidUpdate (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a0961417399ac099b06754f8fad70546d}


returns wherether automatic fluid update is enabled 



Definition at line 80 of file Solver.h.



References m\_\-enableAutoFluid.


\begin{DoxyCode}
{ return m_enableAutoFluid; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a0961417399ac099b06754f8fad70546d_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_afa3aa866448665b98b9868ae43ac5eab}{
\index{Solver@{Solver}!getFluidIdFromName@{getFluidIdFromName}}
\index{getFluidIdFromName@{getFluidIdFromName}!Solver@{Solver}}
\subsubsection[{getFluidIdFromName}]{\setlength{\rightskip}{0pt plus 5cm}int Solver::getFluidIdFromName (
\begin{DoxyParamCaption}
\item[{const std::string}]{\_\-name}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_afa3aa866448665b98b9868ae43ac5eab}


get a particle fluid id from its name 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-name} & the fluid name \\
\hline
\end{DoxyParams}


Definition at line 112 of file Solver.cpp.



References m\_\-hoseParticlePrototypeList.


\begin{DoxyCode}
{
    //assume id to be of the first fluid
    int id = 0;

    //loop through hose prototype list
    for (int i = 0; i < m_hoseParticlePrototypeList.size(); i++)
    {
        //compare names
        if (m_hoseParticlePrototypeList[i].getName() == _name)
        {
            id = i;
            break;
        }
    }

    return id;
}
\end{DoxyCode}
\hypertarget{class_solver_a644510478bf31e777f1c819dcd6ecb98}{
\index{Solver@{Solver}!getHoseCenter@{getHoseCenter}}
\index{getHoseCenter@{getHoseCenter}!Solver@{Solver}}
\subsubsection[{getHoseCenter}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector Solver::getHoseCenter (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a644510478bf31e777f1c819dcd6ecb98}


return the centre of the hose 



Definition at line 92 of file Solver.h.



References m\_\-hoseCenter.


\begin{DoxyCode}
{ return m_hoseCenter; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a644510478bf31e777f1c819dcd6ecb98_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a86102cbc9dd46497658f981ef78dc827}{
\index{Solver@{Solver}!getHoseParticlePrototypeList@{getHoseParticlePrototypeList}}
\index{getHoseParticlePrototypeList@{getHoseParticlePrototypeList}!Solver@{Solver}}
\subsubsection[{getHoseParticlePrototypeList}]{\setlength{\rightskip}{0pt plus 5cm}std::vector$<${\bf FluidParticle}$>$ Solver::getHoseParticlePrototypeList (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a86102cbc9dd46497658f981ef78dc827}


return the list of fluid prototypes 



Definition at line 132 of file Solver.h.



References m\_\-hoseParticlePrototypeList.


\begin{DoxyCode}
{ return m_hoseParticlePrototypeList; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a86102cbc9dd46497658f981ef78dc827_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a7e02195cbbe42c28c21462ab9a715be9}{
\index{Solver@{Solver}!getHoseVelocity@{getHoseVelocity}}
\index{getHoseVelocity@{getHoseVelocity}!Solver@{Solver}}
\subsubsection[{getHoseVelocity}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector Solver::getHoseVelocity (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a7e02195cbbe42c28c21462ab9a715be9}


return the velocity of the hose 



Definition at line 95 of file Solver.h.



References m\_\-hoseVelocity.


\begin{DoxyCode}
{ return m_hoseVelocity; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a7e02195cbbe42c28c21462ab9a715be9_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a66eabb386a77b32a57b27dfda72390a0}{
\index{Solver@{Solver}!getHoseWaitUntilHitBoundary@{getHoseWaitUntilHitBoundary}}
\index{getHoseWaitUntilHitBoundary@{getHoseWaitUntilHitBoundary}!Solver@{Solver}}
\subsubsection[{getHoseWaitUntilHitBoundary}]{\setlength{\rightskip}{0pt plus 5cm}bool Solver::getHoseWaitUntilHitBoundary (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a66eabb386a77b32a57b27dfda72390a0}


return whether the hose particles wait until they first hit the boundary before they act as fluid 



Definition at line 98 of file Solver.h.



References m\_\-hoseWaitUntilHitBoundary.


\begin{DoxyCode}
{ return m_hoseWaitUntilHitBoundary; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a66eabb386a77b32a57b27dfda72390a0_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a44222e716998ab995593ad7a8e2ccef8}{
\index{Solver@{Solver}!getHoseWaitUntilHitRBD@{getHoseWaitUntilHitRBD}}
\index{getHoseWaitUntilHitRBD@{getHoseWaitUntilHitRBD}!Solver@{Solver}}
\subsubsection[{getHoseWaitUntilHitRBD}]{\setlength{\rightskip}{0pt plus 5cm}bool Solver::getHoseWaitUntilHitRBD (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a44222e716998ab995593ad7a8e2ccef8}


toggles whether the hose particles wait until they first hit RBDs before they act as fluid 



Definition at line 101 of file Solver.h.



References m\_\-hoseWaitUntilHitRBD.


\begin{DoxyCode}
{ return m_hoseWaitUntilHitRBD; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a44222e716998ab995593ad7a8e2ccef8_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a4673b7a59a2cceddb90f4553f96c526f}{
\index{Solver@{Solver}!getNameList@{getNameList}}
\index{getNameList@{getNameList}!Solver@{Solver}}
\subsubsection[{getNameList}]{\setlength{\rightskip}{0pt plus 5cm}std::vector$<$ std::string $>$ Solver::getNameList (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_solver_a4673b7a59a2cceddb90f4553f96c526f}


return the list of fluid names, used for caching 



Definition at line 434 of file Solver.cpp.



References m\_\-hoseParticlePrototypeList.


\begin{DoxyCode}
{
    std::vector<std::string> list;
    list.reserve(m_hoseParticlePrototypeList.size());

    for (int i = 0; i < m_hoseParticlePrototypeList.size(); ++i) list.push_back(
      m_hoseParticlePrototypeList[i].getName());

    return list;
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a4673b7a59a2cceddb90f4553f96c526f_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a738ef3a108a4c128bb860a08c4d5f85b}{
\index{Solver@{Solver}!getPositionList@{getPositionList}}
\index{getPositionList@{getPositionList}!Solver@{Solver}}
\subsubsection[{getPositionList}]{\setlength{\rightskip}{0pt plus 5cm}std::vector$<$ std::vector$<$ ngl::Vector $>$ $>$ Solver::getPositionList (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_solver_a738ef3a108a4c128bb860a08c4d5f85b}


return a 2d list of the position of particles, used for caching 



Definition at line 404 of file Solver.cpp.



References m\_\-hoseParticlePrototypeList, and m\_\-particleList.


\begin{DoxyCode}
{
    std::vector<std::vector<ngl::Vector> > positionList;

    //loop through the prototype list that contains 1 particle prototype for each
       fluid
    for (int i = 0; i < m_hoseParticlePrototypeList.size(); ++i)
    {
        //get name
        std::string name = m_hoseParticlePrototypeList[i].getName();
        std::vector<ngl::Vector> list;
        list.reserve(m_particleList.size());

        //loop through particle list
        for (int j = 0; j < m_particleList.size(); ++j)
        {
            //search for particles having this name
            if (m_particleList[j].getName() == name)
            {
                //add this particle's position to list
                list.push_back(m_particleList[j].getPosition());
            }
        }

        //add this fluid's position list to the big list
        positionList.push_back(list);
    }

    return positionList;
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a738ef3a108a4c128bb860a08c4d5f85b_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a8b117559b2b80d11a9f9dc3752246c06}{
\index{Solver@{Solver}!getSmoothingLength@{getSmoothingLength}}
\index{getSmoothingLength@{getSmoothingLength}!Solver@{Solver}}
\subsubsection[{getSmoothingLength}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real Solver::getSmoothingLength (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
) const\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a8b117559b2b80d11a9f9dc3752246c06}


return the smoothing length of the neighbour search 



Definition at line 86 of file Solver.h.



References m\_\-smoothingLength.


\begin{DoxyCode}
{ return m_smoothingLength; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=394pt]{class_solver_a8b117559b2b80d11a9f9dc3752246c06_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a693fcda57de13884c032ef7503dc3151}{
\index{Solver@{Solver}!initialiseDrawing@{initialiseDrawing}}
\index{initialiseDrawing@{initialiseDrawing}!Solver@{Solver}}
\subsubsection[{initialiseDrawing}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::initialiseDrawing (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_solver_a693fcda57de13884c032ef7503dc3151}


initialise opengl drawing 



Definition at line 54 of file Solver.cpp.


\begin{DoxyCode}
{
    ngl::VBOPrimitives* prim = ngl::VBOPrimitives::instance();

    //create vbo for particle sphere
    prim->createVBOSphere("particleSphere", 0.17, 10);
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=352pt]{class_solver_a693fcda57de13884c032ef7503dc3151_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a2672537c98f708e8971fd5cf151035cd}{
\index{Solver@{Solver}!injectParticles@{injectParticles}}
\index{injectParticles@{injectParticles}!Solver@{Solver}}
\subsubsection[{injectParticles}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::injectParticles (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)}}
\label{class_solver_a2672537c98f708e8971fd5cf151035cd}


inject/pumps in hose particles into the simulation 



Definition at line 131 of file Solver.cpp.



References m\_\-currentHoseableFluid, m\_\-hoseCenter, m\_\-hoseInitialCenter, m\_\-hoseParticleList, m\_\-hoseParticlePrototypeList, m\_\-hoseVelocity, m\_\-hoseWaitUntilHitBoundary, m\_\-hoseWaitUntilHitRBD, m\_\-neighbour, m\_\-particleList, m\_\-smoothingLength, Neighbour::reInitialise(), Configuration::s\_\-nextParticleId, Particle::setId(), Particle::setPosition(), Particle::setVelocity(), FluidParticle::setWaitUntilFirstHitBoundary(), and FluidParticle::setWaitUntilFirstHitRBD().


\begin{DoxyCode}
{
    std::vector<FluidParticle> l;

    //get translate in hose center
    ngl::Vector translatedVector = m_hoseCenter - m_hoseInitialCenter;

    //get prototype particle from hose prototype list
    FluidParticle prototypeParticle = m_hoseParticlePrototypeList[
      m_currentHoseableFluid];

    //loop through hose particles and add particles to solver particle list
    for (int i = 0; i < m_hoseParticleList.size(); i++)
    {
        //create particle from prototype particle
        FluidParticle p(prototypeParticle);

        //set id of new particle
        p.setId(Configuration::s_nextParticleId++);

        //set position of new particle = hose particle(i) + translatedVector
        p.setPosition(m_hoseParticleList[i].getPosition() + translatedVector);

        //set velocity of new particle
        p.setVelocity(m_hoseVelocity);

        //set wait until first hit properties
        p.setWaitUntilFirstHitBoundary(m_hoseWaitUntilHitBoundary);
        p.setWaitUntilFirstHitRBD(m_hoseWaitUntilHitRBD);

        //add new particle to particle list
        m_particleList.push_back(p);
    }

    std::cout << "Hose for fluid : " << m_currentHoseableFluid << "\tnew particle
       count : " << m_particleList.size() << "\n";

    //reinitialise neighbour structure due to new particles being added
    m_neighbour->reInitialise(m_particleList.size(), m_smoothingLength);
}
\end{DoxyCode}


Here is the call graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a2672537c98f708e8971fd5cf151035cd_cgraph}
\end{center}
\end{figure}




Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a2672537c98f708e8971fd5cf151035cd_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a62a6ace7a8ff2e18dd6e2b6475b4912c}{
\index{Solver@{Solver}!normalise@{normalise}}
\index{normalise@{normalise}!Solver@{Solver}}
\subsubsection[{normalise}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector Solver::normalise (
\begin{DoxyParamCaption}
\item[{const ngl::Vector}]{\_\-vector}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a62a6ace7a8ff2e18dd6e2b6475b4912c}


normalise a vector 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-vector} & the vector to normalise \\
\hline
\end{DoxyParams}


Definition at line 103 of file Solver.cpp.


\begin{DoxyCode}
{
    ngl::Vector v = _vector;
    if (_vector.length() > 0.0001f) v.normalize();

    return v;
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=382pt]{class_solver_a62a6ace7a8ff2e18dd6e2b6475b4912c_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a0d31c43c6e8e4acff7556e4410043073}{
\index{Solver@{Solver}!render@{render}}
\index{render@{render}!Solver@{Solver}}
\subsubsection[{render}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::render (
\begin{DoxyParamCaption}
\item[{ngl::TransformStack}]{\_\-txStack, }
\item[{{\bf ShaderLibrary} $\ast$}]{io\_\-sman, }
\item[{const std::string}]{\_\-shader}
\end{DoxyParamCaption}
)}}
\label{class_solver_a0d31c43c6e8e4acff7556e4410043073}


display the particle spheres 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-txStack} & the transformation stack used to maintain opengl states \\
\hline
\mbox{\tt in,out}  & {\em io\_\-sman} & the shader library \\
\hline
\mbox{\tt in}  & {\em \_\-shader} & the shader used to display the spheres \\
\hline
\end{DoxyParams}


Definition at line 378 of file Solver.cpp.



References ShaderLibrary::updateColor(), and ShaderLibrary::updateModel().


\begin{DoxyCode}
{
    ngl::VBOPrimitives* prim = ngl::VBOPrimitives::instance();

    _txStack.pushTransform();
    {
        for (int i = 0; i < m_particleList.size(); ++i)
        {
            _txStack.getCurrentTransform().setPosition(m_particleList[i].getPosit
      ion().m_x, m_particleList[i].getPosition().m_y, m_particleList[i].getPosition().m
      _z);

            //pass vertex info to shader
            io_sman->updateModel(_shader, _txStack.getCurrAndGlobal().getMatrix()
      , false);

            //pass color info to shader
            io_sman->updateColor(_shader, m_particleList[i].getColour(), false);

            prim->draw("particleSphere");
        }
    }
    _txStack.popTransform();
}
\end{DoxyCode}


Here is the call graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=330pt]{class_solver_a0d31c43c6e8e4acff7556e4410043073_cgraph}
\end{center}
\end{figure}




Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=294pt]{class_solver_a0d31c43c6e8e4acff7556e4410043073_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a826574de203172353c534f231db268c0}{
\index{Solver@{Solver}!setCurrentHoseableFluid@{setCurrentHoseableFluid}}
\index{setCurrentHoseableFluid@{setCurrentHoseableFluid}!Solver@{Solver}}
\subsubsection[{setCurrentHoseableFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::setCurrentHoseableFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-v}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a826574de203172353c534f231db268c0}


set the current hoseable fluid id 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-v} & the fluid id \\
\hline
\end{DoxyParams}


Definition at line 77 of file Solver.h.



References m\_\-currentHoseableFluid.


\begin{DoxyCode}
{ m_currentHoseableFluid = _v; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a826574de203172353c534f231db268c0_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a27ff860a5d81e7fe1f89d9bd020ccd7c}{
\index{Solver@{Solver}!setDrawHoseMarker@{setDrawHoseMarker}}
\index{setDrawHoseMarker@{setDrawHoseMarker}!Solver@{Solver}}
\subsubsection[{setDrawHoseMarker}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::setDrawHoseMarker (
\begin{DoxyParamCaption}
\item[{const bool}]{\_\-v}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a27ff860a5d81e7fe1f89d9bd020ccd7c}


set flag of whether to draw hose marker 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-v} & the new value \\
\hline
\end{DoxyParams}


Definition at line 113 of file Solver.h.



References m\_\-drawHoseMarker.


\begin{DoxyCode}
{ m_drawHoseMarker = _v; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a27ff860a5d81e7fe1f89d9bd020ccd7c_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a592a9c837eb3409ebcb9cf4a61d4c5fa}{
\index{Solver@{Solver}!setHoseCenter@{setHoseCenter}}
\index{setHoseCenter@{setHoseCenter}!Solver@{Solver}}
\subsubsection[{setHoseCenter}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::setHoseCenter (
\begin{DoxyParamCaption}
\item[{const ngl::Vector}]{\_\-v}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a592a9c837eb3409ebcb9cf4a61d4c5fa}


set the centre of the hose 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-v} & the new value \\
\hline
\end{DoxyParams}


Definition at line 117 of file Solver.h.



References m\_\-hoseCenter.


\begin{DoxyCode}
{ m_hoseCenter = _v; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a592a9c837eb3409ebcb9cf4a61d4c5fa_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_ab7bc3f274693f9395cbbc7eb9d255cda}{
\index{Solver@{Solver}!setHoseVelocity@{setHoseVelocity}}
\index{setHoseVelocity@{setHoseVelocity}!Solver@{Solver}}
\subsubsection[{setHoseVelocity}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::setHoseVelocity (
\begin{DoxyParamCaption}
\item[{const ngl::Vector}]{\_\-v}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_ab7bc3f274693f9395cbbc7eb9d255cda}


return the velocity of the hose 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-v} & the new value \\
\hline
\end{DoxyParams}


Definition at line 121 of file Solver.h.



References m\_\-hoseVelocity.


\begin{DoxyCode}
{ m_hoseVelocity = _v; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_ab7bc3f274693f9395cbbc7eb9d255cda_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a23736b6b761b1d553ee320f5b64c8e52}{
\index{Solver@{Solver}!setHoseWaitUntilHitBoundary@{setHoseWaitUntilHitBoundary}}
\index{setHoseWaitUntilHitBoundary@{setHoseWaitUntilHitBoundary}!Solver@{Solver}}
\subsubsection[{setHoseWaitUntilHitBoundary}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::setHoseWaitUntilHitBoundary (
\begin{DoxyParamCaption}
\item[{const bool}]{\_\-v}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a23736b6b761b1d553ee320f5b64c8e52}


set whether the hose particles wait until they first hit the boundary before they act as fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-v} & the new flag \\
\hline
\end{DoxyParams}


Definition at line 105 of file Solver.h.



References m\_\-hoseWaitUntilHitBoundary.


\begin{DoxyCode}
{ m_hoseWaitUntilHitBoundary = _v; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a23736b6b761b1d553ee320f5b64c8e52_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_ac1600f3c384f56ec0a83bd3a25a38cd1}{
\index{Solver@{Solver}!setHoseWaitUntilHitRBD@{setHoseWaitUntilHitRBD}}
\index{setHoseWaitUntilHitRBD@{setHoseWaitUntilHitRBD}!Solver@{Solver}}
\subsubsection[{setHoseWaitUntilHitRBD}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::setHoseWaitUntilHitRBD (
\begin{DoxyParamCaption}
\item[{const bool}]{\_\-v}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_ac1600f3c384f56ec0a83bd3a25a38cd1}


set whether the hose particles wait until they first hit RBDs before they act as fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-v} & the new flag \\
\hline
\end{DoxyParams}


Definition at line 109 of file Solver.h.



References m\_\-hoseWaitUntilHitRBD.


\begin{DoxyCode}
{ m_hoseWaitUntilHitRBD = _v; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_ac1600f3c384f56ec0a83bd3a25a38cd1_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a3aa03b6f3e032453ddf8c8e54fb227ec}{
\index{Solver@{Solver}!setSmoothingLength@{setSmoothingLength}}
\index{setSmoothingLength@{setSmoothingLength}!Solver@{Solver}}
\subsubsection[{setSmoothingLength}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::setSmoothingLength (
\begin{DoxyParamCaption}
\item[{const ngl::Real}]{\_\-v}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a3aa03b6f3e032453ddf8c8e54fb227ec}


set the smoothing kernel length 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-v} & updated smoothing length \\
\hline
\end{DoxyParams}


Definition at line 125 of file Solver.h.



References m\_\-neighbour, m\_\-smoothingLength, and Neighbour::setCellSize().


\begin{DoxyCode}
    {
        m_smoothingLength = _v;
        m_neighbour->setCellSize(_v);
    }
\end{DoxyCode}


Here is the call graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=370pt]{class_solver_a3aa03b6f3e032453ddf8c8e54fb227ec_cgraph}
\end{center}
\end{figure}




Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a3aa03b6f3e032453ddf8c8e54fb227ec_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a73637ce7688c9507abb31c09665d3237}{
\index{Solver@{Solver}!toggleEnableAutoFluidUpdate@{toggleEnableAutoFluidUpdate}}
\index{toggleEnableAutoFluidUpdate@{toggleEnableAutoFluidUpdate}!Solver@{Solver}}
\subsubsection[{toggleEnableAutoFluidUpdate}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::toggleEnableAutoFluidUpdate (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_a73637ce7688c9507abb31c09665d3237}


toggles the state of the automatic fluid update flag 



Definition at line 83 of file Solver.h.



References m\_\-enableAutoFluid.


\begin{DoxyCode}
{ m_enableAutoFluid ^= true; }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a73637ce7688c9507abb31c09665d3237_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_abb5641e50e11d98e800f0018248849c9}{
\index{Solver@{Solver}!toggleNextHoseableFluid@{toggleNextHoseableFluid}}
\index{toggleNextHoseableFluid@{toggleNextHoseableFluid}!Solver@{Solver}}
\subsubsection[{toggleNextHoseableFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::toggleNextHoseableFluid (
\begin{DoxyParamCaption}
{}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}inline\mbox{]}}}}
\label{class_solver_abb5641e50e11d98e800f0018248849c9}


toggle between the fluids to determine which one will be used by the hose 



Definition at line 69 of file Solver.h.



References m\_\-currentHoseableFluid, and m\_\-hoseParticlePrototypeList.


\begin{DoxyCode}
    {
        m_currentHoseableFluid = ++m_currentHoseableFluid % 
      m_hoseParticlePrototypeList.size();
        std::cout << "New Hoseable Fluid Id : " << m_currentHoseableFluid << "\n"
      ;
    }
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_abb5641e50e11d98e800f0018248849c9_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a445201a1ac13e8e855cd74945602f69f}{
\index{Solver@{Solver}!updateFluid@{updateFluid}}
\index{updateFluid@{updateFluid}!Solver@{Solver}}
\subsubsection[{updateFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateFluid (
\begin{DoxyParamCaption}
\item[{{\bf Environment} $\ast$}]{io\_\-environment, }
\item[{{\bf Integration} $\ast$}]{\_\-integration}
\end{DoxyParamCaption}
)}}
\label{class_solver_a445201a1ac13e8e855cd74945602f69f}


update the fluid state at each timestep interval 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in,out}  & {\em io\_\-environment} & the environment that holds the list of obstacles \\
\hline
\mbox{\tt in}  & {\em \_\-integration} & the integration object for the simulation \\
\hline
\end{DoxyParams}


Definition at line 171 of file Solver.cpp.



References Environment::checkAndResolveCollision(), FluidParticle::getDensity(), Particle::getId(), Particle::getMass(), Particle::getPosition(), FluidParticle::getPressure(), Particle::getVelocity(), Integration::integrateNext(), Configuration::s\_\-accelerationOfFreeFall, and Environment::updateObstacles().


\begin{DoxyCode}
{
    //clear neighbour map
    m_neighbour->clearHashmap();

#pragma omp parallel
{
    //refresh neighbour list
    m_neighbour->refreshHashmap(m_particleList);
}

#pragma omp parallel
{
#pragma omp for schedule(dynamic, 50)
    //density-pressure calculations
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        //get neighbours of current particle
        std::vector<FluidParticle> neighbourList = m_neighbour->
      determineNeighbours(m_particleList[i].getPosition());

        //calculate density and pressure
        ngl::Real density = 0.0;
        for (int j = 0; j < neighbourList.size(); j++)
        {
            //accumulate density
            density += neighbourList[j].getMass() * WKernel_Poly((m_particleList[
      i].getPosition() - neighbourList[j].getPosition()).length());
        }
        m_particleList[i].setDensity(density);

        //calculate pressure
        m_particleList[i].calculatePressure();
    }

#pragma omp for schedule(dynamic, 50)
    //force calculations
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        //reset net forces accumulate
        m_particleList[i].resetForce();

        //get neighbours of current particle
        std::vector<FluidParticle> neighbourList = m_neighbour->
      determineNeighbours(m_particleList[i].getPosition());

        //calculate internal forces of current particle
        ngl::Real massPerDensity = 0;
        ngl::Vector separationVector = 0;
        ngl::Real separationLength = 0.0;

        ngl::Vector pressure = 0;
        ngl::Vector viscosity = 0;

        ngl::Vector surfaceGradient = 0;
        ngl::Real surfaceLaplacian = 0;

        ngl::Vector surfaceTensionGradient = 0;
        ngl::Real surfaceTensionLaplacian = 0;
        ngl::Vector interfaceTensionGradient = 0;
        ngl::Real interfaceTensionLaplacian = 0;

        //apply fluid rules if enabled
        if (m_particleList[i].fluidRulesEnabled())
        {
            for (int j = 0; j < neighbourList.size(); j++)
            {
                //get neighbour
                FluidParticle neighbour = neighbourList[j];

                //pre-calculate some repetitive values
                massPerDensity = neighbour.getMass() / neighbour.getDensity();
                separationVector = m_particleList[i].getPosition() - neighbour.
      getPosition();
                separationLength = separationVector.length();

                //add in pressure and viscosity force only for neighbours, not th
      e current particle itself
                if (neighbour.getId() != m_particleList[i].getId())
                {
                    //accumulate pressure force component
                    pressure = pressure +
                               (
                                       ((m_particleList[i].getPressure() / pow(
      m_particleList[i].getDensity(), 2)) + (neighbour.getPressure() / pow(neighbour.
      getDensity(), 2))) *
                                       neighbour.getMass() *
                                       WKernel_Pressure_Gradient(separationVector
      )
                                       );

                    //accumulate viscous force component
                    viscosity = viscosity +
                                (
                                        /*((currentParticle.getViscosityConstant(
      ) + neighbour.getViscosityConstant()) / 2.0) **/
                                        massPerDensity *
                                        (neighbour.getVelocity() - 
      m_particleList[i].getVelocity()) *
                                        WKernel_Viscosity_Laplacian(separationLen
      gth)
                                        );
                }

                //accumulate surface tension-interface force component
                surfaceGradient = WKernel_Poly_Gradient(separationVector);
                surfaceLaplacian = WKernel_Poly_Laplacian(separationLength);

                //accumulate surface gradient
                surfaceTensionGradient = surfaceTensionGradient +
                                         (
                                                 massPerDensity *
                                                 m_particleList[i].getSurfaceColo
      rCoefficient() *
                                                 surfaceGradient
                                                 );

                //accumulate surface laplacian
                surfaceTensionLaplacian = surfaceTensionLaplacian +
                                          (
                                                  massPerDensity *
                                                  m_particleList[i].getSurfaceCol
      orCoefficient() *
                                                  surfaceLaplacian
                                                  );

                //accumulate interface gradient
                interfaceTensionGradient = surfaceTensionGradient +
                                           (
                                                   massPerDensity *
                                                   m_particleList[i].getInterface
      ColorCoefficient() *
                                                   surfaceGradient
                                                   );

                //accumulate interface laplacian
                interfaceTensionLaplacian = surfaceTensionLaplacian +
                                            (
                                                    massPerDensity *
                                                    m_particleList[i].getInterfac
      eColorCoefficient() *
                                                    surfaceLaplacian
                                                    );

            }
        }

        //calculate pressure force
        m_particleList[i].setPressureForce(-1.0 * m_particleList[i].getDensity() 
      * pressure);

        //calculate viscosity force
        m_particleList[i].setViscosityForce(viscosity * m_particleList[i].getVisc
      osityConstant());

        //calculate surface tension force
        m_particleList[i].setSurfaceTensionForce(0.0);
        if (surfaceTensionGradient.length() > m_particleList[i].getSurfaceTension
      Threshold())
        {
            m_particleList[i].setSurfaceTensionForce(-1.0 * m_particleList[i].get
      SurfaceTensionCoefficient() * normalise(surfaceTensionGradient) * surfaceTensionL
      aplacian);
        }

        //calculate interface tension force
        m_particleList[i].setInterfaceTensionForce(0.0);
        if (interfaceTensionGradient.length() > m_particleList[i].getInterfaceTen
      sionThreshold())
        {
            m_particleList[i].setInterfaceTensionForce(-1.0 * m_particleList[i].g
      etInterfaceTensionCoefficient() * normalise(interfaceTensionGradient) * interface
      TensionLaplacian);
        }

        //calculate gravity force (=density * g)
        m_particleList[i].setGravityForce(new ngl::Vector(0, m_particleList[i].ge
      tDensity() * Configuration::s_accelerationOfFreeFall, 0));

        //calculate acceleration (= force / mass)
        m_particleList[i].accumulateNetForce(m_particleList[i].getPressureForce()
      );
        m_particleList[i].accumulateNetForce(m_particleList[i].getViscosityForce(
      ));
        m_particleList[i].accumulateNetForce(m_particleList[i].getSurfaceTensionF
      orce());
        m_particleList[i].accumulateNetForce(m_particleList[i].getInterfaceTensio
      nForce());
        m_particleList[i].accumulateNetForce(m_particleList[i].getGravityForce())
      ;
        m_particleList[i].updateAcceleration(m_particleList[i].getNetForce() / 
      m_particleList[i].getDensity());
    }

#pragma omp for schedule(dynamic, 50)
    //fluid integration and movement
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (m_particleList[i].getMoveable())
        {
            //determine next (position, velocity) of particle
            _integration->integrateNext(m_particleList[i]);
        }
    }

#pragma omp single
    //obstacles movement
    io_environment->updateObstacles(_integration);

#pragma omp for schedule(dynamic, 50)
    //collision check and resolution for fluid particles
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        //check and resolve collision against obstacles and boundary
        bool hitBoundary = false; bool hitRBD = false;
        io_environment->checkAndResolveCollision(m_particleList[i], hitBoundary, 
      hitRBD, false);

        //update first time hit issues
        m_particleList[i].updateHitForTheFirstTime(hitBoundary, hitRBD);
    }
}

//    //increment iteration counter
//    iteration++;
//    std::cout << iteration << "\n";

//    if ((iteration % 1001) == 0)
//    {
//        time_t now; time(&now);
//        printf("%s\n", ctime(&now));
//    }
}
\end{DoxyCode}


Here is the call graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a445201a1ac13e8e855cd74945602f69f_cgraph}
\end{center}
\end{figure}




Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a445201a1ac13e8e855cd74945602f69f_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a731102ccd50860362b79e39357b5354b}{
\index{Solver@{Solver}!updateGasConstantForFluid@{updateGasConstantForFluid}}
\index{updateGasConstantForFluid@{updateGasConstantForFluid}!Solver@{Solver}}
\subsubsection[{updateGasConstantForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateGasConstantForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-gasConstant}
\end{DoxyParamCaption}
)}}
\label{class_solver_a731102ccd50860362b79e39357b5354b}


update gas constant of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-gasConstant} & the new gas constant \\
\hline
\end{DoxyParams}


Definition at line 464 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setGasConstant(_gasConstant);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setGasConstant(_gasConstant);
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a731102ccd50860362b79e39357b5354b_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_aeabd083481cb2e33014cd7d0bb8129a0}{
\index{Solver@{Solver}!updateInterfaceCoefficientForFluid@{updateInterfaceCoefficientForFluid}}
\index{updateInterfaceCoefficientForFluid@{updateInterfaceCoefficientForFluid}!Solver@{Solver}}
\subsubsection[{updateInterfaceCoefficientForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateInterfaceCoefficientForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-coefficient}
\end{DoxyParamCaption}
)}}
\label{class_solver_aeabd083481cb2e33014cd7d0bb8129a0}


update interface coefficient of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-coefficient} & the new coefficient \\
\hline
\end{DoxyParams}


Definition at line 540 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setInterfaceTensionCoefficient(_coefficient);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setInterfaceTensionCoefficient(_coeffic
      ient);
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_aeabd083481cb2e33014cd7d0bb8129a0_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a8195de06f78ee8f4778e8528be93611b}{
\index{Solver@{Solver}!updateInterfaceColorForFluid@{updateInterfaceColorForFluid}}
\index{updateInterfaceColorForFluid@{updateInterfaceColorForFluid}!Solver@{Solver}}
\subsubsection[{updateInterfaceColorForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateInterfaceColorForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-color}
\end{DoxyParamCaption}
)}}
\label{class_solver_a8195de06f78ee8f4778e8528be93611b}


update interface color of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-color} & the new color \\
\hline
\end{DoxyParams}


Definition at line 578 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setInterfaceColorCoefficient(_color);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setInterfaceColorCoefficient(_color);
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a8195de06f78ee8f4778e8528be93611b_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a4ce3c2b6ab7a8ea665f53dd364428c40}{
\index{Solver@{Solver}!updateInterfaceThresholdForFluid@{updateInterfaceThresholdForFluid}}
\index{updateInterfaceThresholdForFluid@{updateInterfaceThresholdForFluid}!Solver@{Solver}}
\subsubsection[{updateInterfaceThresholdForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateInterfaceThresholdForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-threshold}
\end{DoxyParamCaption}
)}}
\label{class_solver_a4ce3c2b6ab7a8ea665f53dd364428c40}


update interface threshold of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-threshold} & the new threshold \\
\hline
\end{DoxyParams}


Definition at line 559 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setInterfaceTensionThreshold(_threshold);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setInterfaceTensionThreshold(_threshold
      );
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a4ce3c2b6ab7a8ea665f53dd364428c40_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a8f46937e18acd18807b3c10805c37212}{
\index{Solver@{Solver}!updateRestDensityForFluid@{updateRestDensityForFluid}}
\index{updateRestDensityForFluid@{updateRestDensityForFluid}!Solver@{Solver}}
\subsubsection[{updateRestDensityForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateRestDensityForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-restDensity}
\end{DoxyParamCaption}
)}}
\label{class_solver_a8f46937e18acd18807b3c10805c37212}


update rest density of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-restDensity} & the new density \\
\hline
\end{DoxyParams}


Definition at line 445 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setMaterialRestDensity(_restDensity);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setMaterialRestDensity(_restDensity);
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a8f46937e18acd18807b3c10805c37212_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a2ed2b6ce87013e8ed55abbc1ca3a05b6}{
\index{Solver@{Solver}!updateSurfaceCoefficientForFluid@{updateSurfaceCoefficientForFluid}}
\index{updateSurfaceCoefficientForFluid@{updateSurfaceCoefficientForFluid}!Solver@{Solver}}
\subsubsection[{updateSurfaceCoefficientForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateSurfaceCoefficientForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-coefficient}
\end{DoxyParamCaption}
)}}
\label{class_solver_a2ed2b6ce87013e8ed55abbc1ca3a05b6}


update surface coefficient of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-coefficient} & the new coefficient \\
\hline
\end{DoxyParams}


Definition at line 502 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setSurfaceTensionCoefficient(_coefficient);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setSurfaceTensionCoefficient(_coefficie
      nt);
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a2ed2b6ce87013e8ed55abbc1ca3a05b6_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a56927b0f0d5365b8b85c087acbf342c2}{
\index{Solver@{Solver}!updateSurfaceThresholdForFluid@{updateSurfaceThresholdForFluid}}
\index{updateSurfaceThresholdForFluid@{updateSurfaceThresholdForFluid}!Solver@{Solver}}
\subsubsection[{updateSurfaceThresholdForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateSurfaceThresholdForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-threshold}
\end{DoxyParamCaption}
)}}
\label{class_solver_a56927b0f0d5365b8b85c087acbf342c2}


update surface threshold of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-threshold} & the new threshold \\
\hline
\end{DoxyParams}


Definition at line 521 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setSurfaceTensionThreshold(_threshold);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setSurfaceTensionThreshold(_threshold);
      
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_a56927b0f0d5365b8b85c087acbf342c2_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_afd8b0440fbd7c0e5a95098b250a5b5c4}{
\index{Solver@{Solver}!updateViscosityConstantForFluid@{updateViscosityConstantForFluid}}
\index{updateViscosityConstantForFluid@{updateViscosityConstantForFluid}!Solver@{Solver}}
\subsubsection[{updateViscosityConstantForFluid}]{\setlength{\rightskip}{0pt plus 5cm}void Solver::updateViscosityConstantForFluid (
\begin{DoxyParamCaption}
\item[{const int}]{\_\-fluidId, }
\item[{const ngl::Real}]{\_\-viscosityConstant}
\end{DoxyParamCaption}
)}}
\label{class_solver_afd8b0440fbd7c0e5a95098b250a5b5c4}


update viscosity constant of a fluid 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-fluidId} & the fluid to update \\
\hline
\mbox{\tt in}  & {\em \_\-viscosityConstant} & the new viscosity constant \\
\hline
\end{DoxyParams}


Definition at line 483 of file Solver.cpp.


\begin{DoxyCode}
{
    //loop for particles of the concerned fluid
    for (int i = 0; i < m_particleList.size(); ++i)
    {
        if (getFluidIdFromName(m_particleList[i].getName()) == _fluidId)
        {
            //found particles of the concerned fluid -> update it
            m_particleList[i].setViscosityConstant(_viscosityConstant);
        }
    }

    m_hoseParticlePrototypeList[_fluidId].setViscosityConstant(_viscosityConstant
      );
}
\end{DoxyCode}


Here is the caller graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=400pt]{class_solver_afd8b0440fbd7c0e5a95098b250a5b5c4_icgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_aaa73637a35872bb7aa1883728e9da51f}{
\index{Solver@{Solver}!WKernel\_\-Poly@{WKernel\_\-Poly}}
\index{WKernel\_\-Poly@{WKernel\_\-Poly}!Solver@{Solver}}
\subsubsection[{WKernel\_\-Poly}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real Solver::WKernel\_\-Poly (
\begin{DoxyParamCaption}
\item[{const ngl::Real}]{\_\-separationLength}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_aaa73637a35872bb7aa1883728e9da51f}


calculate the poly 6 kernel 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-separationLength} & the separation distance between a particle and its neighbour \\
\hline
\end{DoxyParams}


Definition at line 62 of file Solver.cpp.



References m\_\-smoothingLength, and m\_\-weightPoly.


\begin{DoxyCode}
{
    ngl::Real weight = m_weightPoly * (pow(pow(m_smoothingLength, 2) - pow(_separ
      ationLength, 2), 3));

    return weight;
}
\end{DoxyCode}
\hypertarget{class_solver_a5462e249d35a3467864f449db410a626}{
\index{Solver@{Solver}!WKernel\_\-Poly\_\-Gradient@{WKernel\_\-Poly\_\-Gradient}}
\index{WKernel\_\-Poly\_\-Gradient@{WKernel\_\-Poly\_\-Gradient}!Solver@{Solver}}
\subsubsection[{WKernel\_\-Poly\_\-Gradient}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector Solver::WKernel\_\-Poly\_\-Gradient (
\begin{DoxyParamCaption}
\item[{const ngl::Vector}]{\_\-separationVector}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a5462e249d35a3467864f449db410a626}


calculate the poly 6 gradient kernel 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-separationVector} & the separation vector between a particle and its neighbour \\
\hline
\end{DoxyParams}


Definition at line 69 of file Solver.cpp.



References m\_\-smoothingLength, and m\_\-weightPolyGradient.


\begin{DoxyCode}
{
    ngl::Vector weight = 0;
    ngl::Real separationLength = _separationVector.length();

    weight = m_weightPolyGradient * _separationVector * pow(pow(
      m_smoothingLength, 2) - pow(separationLength, 2), 2);

    return weight;
}
\end{DoxyCode}
\hypertarget{class_solver_a22bdb89c711ffe08811065684680cc8a}{
\index{Solver@{Solver}!WKernel\_\-Poly\_\-Laplacian@{WKernel\_\-Poly\_\-Laplacian}}
\index{WKernel\_\-Poly\_\-Laplacian@{WKernel\_\-Poly\_\-Laplacian}!Solver@{Solver}}
\subsubsection[{WKernel\_\-Poly\_\-Laplacian}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real Solver::WKernel\_\-Poly\_\-Laplacian (
\begin{DoxyParamCaption}
\item[{const ngl::Real}]{\_\-separationLength}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a22bdb89c711ffe08811065684680cc8a}


calculate the poly 6 laplacian kernel 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-separationLength} & the separation distance between a particle and its neighbour \\
\hline
\end{DoxyParams}


Definition at line 79 of file Solver.cpp.



References m\_\-smoothingLength, and m\_\-weightPolyLaplacian.


\begin{DoxyCode}
{
    ngl::Real weight = m_weightPolyLaplacian * (pow(m_smoothingLength, 2) - pow(_
      separationLength, 2)) * ((3.0 * pow(m_smoothingLength, 2)) - (7.0 * pow(_separati
      onLength, 2)));

    return weight;
}
\end{DoxyCode}
\hypertarget{class_solver_ac17f6ca35c9d92ea29d625dad841f917}{
\index{Solver@{Solver}!WKernel\_\-Pressure\_\-Gradient@{WKernel\_\-Pressure\_\-Gradient}}
\index{WKernel\_\-Pressure\_\-Gradient@{WKernel\_\-Pressure\_\-Gradient}!Solver@{Solver}}
\subsubsection[{WKernel\_\-Pressure\_\-Gradient}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector Solver::WKernel\_\-Pressure\_\-Gradient (
\begin{DoxyParamCaption}
\item[{const ngl::Vector}]{\_\-separationVector}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_ac17f6ca35c9d92ea29d625dad841f917}


calculate the pressure (spiky) gradient kernel 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-separationVector} & the separation vector between a particle and its neighbour \\
\hline
\end{DoxyParams}


Definition at line 86 of file Solver.cpp.



References m\_\-smoothingLength, m\_\-weightPressureGradient, and normalise().


\begin{DoxyCode}
{
    ngl::Vector weight = 0;
    ngl::Real separationLength = _separationVector.length();

    weight = m_weightPressureGradient * pow(m_smoothingLength - separationLength,
       2) * normalise(_separationVector);

    return weight;
}
\end{DoxyCode}


Here is the call graph for this function:\nopagebreak
\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=382pt]{class_solver_ac17f6ca35c9d92ea29d625dad841f917_cgraph}
\end{center}
\end{figure}


\hypertarget{class_solver_a2c0079b0c5d1f74e9fdbbd59b6df4ee7}{
\index{Solver@{Solver}!WKernel\_\-Viscosity\_\-Laplacian@{WKernel\_\-Viscosity\_\-Laplacian}}
\index{WKernel\_\-Viscosity\_\-Laplacian@{WKernel\_\-Viscosity\_\-Laplacian}!Solver@{Solver}}
\subsubsection[{WKernel\_\-Viscosity\_\-Laplacian}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real Solver::WKernel\_\-Viscosity\_\-Laplacian (
\begin{DoxyParamCaption}
\item[{const ngl::Real}]{\_\-separationLength}
\end{DoxyParamCaption}
)\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a2c0079b0c5d1f74e9fdbbd59b6df4ee7}


calculate the viscosity laplacian kernel 


\begin{DoxyParams}[1]{Parameters}
\mbox{\tt in}  & {\em \_\-separationLength} & the separation distance between a particle and its neighbour \\
\hline
\end{DoxyParams}


Definition at line 96 of file Solver.cpp.



References m\_\-smoothingLength, and m\_\-weightViscosityLaplacian.


\begin{DoxyCode}
{
    ngl::Real weight = m_weightViscosityLaplacian * (m_smoothingLength - _separat
      ionLength);

    return weight;
}
\end{DoxyCode}


\subsection{Member Data Documentation}
\hypertarget{class_solver_a9ed412b05483c23c1662cace6c2fa655}{
\index{Solver@{Solver}!m\_\-currentHoseableFluid@{m\_\-currentHoseableFluid}}
\index{m\_\-currentHoseableFluid@{m\_\-currentHoseableFluid}!Solver@{Solver}}
\subsubsection[{m\_\-currentHoseableFluid}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf Solver::m\_\-currentHoseableFluid}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a9ed412b05483c23c1662cace6c2fa655}


the current fluid id that is injected when hose is applied 



Definition at line 245 of file Solver.h.

\hypertarget{class_solver_ac20b1359d36c008204e912930cf63f16}{
\index{Solver@{Solver}!m\_\-drawHoseMarker@{m\_\-drawHoseMarker}}
\index{m\_\-drawHoseMarker@{m\_\-drawHoseMarker}!Solver@{Solver}}
\subsubsection[{m\_\-drawHoseMarker}]{\setlength{\rightskip}{0pt plus 5cm}bool {\bf Solver::m\_\-drawHoseMarker}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_ac20b1359d36c008204e912930cf63f16}


toggles whether to draw hose marker 



Definition at line 257 of file Solver.h.

\hypertarget{class_solver_a26446ff6dafc53811a1fce955b2f80a6}{
\index{Solver@{Solver}!m\_\-enableAutoFluid@{m\_\-enableAutoFluid}}
\index{m\_\-enableAutoFluid@{m\_\-enableAutoFluid}!Solver@{Solver}}
\subsubsection[{m\_\-enableAutoFluid}]{\setlength{\rightskip}{0pt plus 5cm}bool {\bf Solver::m\_\-enableAutoFluid}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a26446ff6dafc53811a1fce955b2f80a6}


flag to control automatic movement of the fluid 



Definition at line 218 of file Solver.h.

\hypertarget{class_solver_a005d898e17088db5cb2694c597017359}{
\index{Solver@{Solver}!m\_\-hoseCenter@{m\_\-hoseCenter}}
\index{m\_\-hoseCenter@{m\_\-hoseCenter}!Solver@{Solver}}
\subsubsection[{m\_\-hoseCenter}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector {\bf Solver::m\_\-hoseCenter}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a005d898e17088db5cb2694c597017359}


the current position where hose particles are injected into the scene 



Definition at line 251 of file Solver.h.

\hypertarget{class_solver_ac2d094ff22778ae503a267db3e861664}{
\index{Solver@{Solver}!m\_\-hoseInitialCenter@{m\_\-hoseInitialCenter}}
\index{m\_\-hoseInitialCenter@{m\_\-hoseInitialCenter}!Solver@{Solver}}
\subsubsection[{m\_\-hoseInitialCenter}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector {\bf Solver::m\_\-hoseInitialCenter}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_ac2d094ff22778ae503a267db3e861664}


the initial position of the hose particles 



Definition at line 248 of file Solver.h.

\hypertarget{class_solver_a947b8362701a0de9f3d61187c71b003f}{
\index{Solver@{Solver}!m\_\-hoseParticleList@{m\_\-hoseParticleList}}
\index{m\_\-hoseParticleList@{m\_\-hoseParticleList}!Solver@{Solver}}
\subsubsection[{m\_\-hoseParticleList}]{\setlength{\rightskip}{0pt plus 5cm}std::vector$<${\bf FluidParticle}$>$ {\bf Solver::m\_\-hoseParticleList}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a947b8362701a0de9f3d61187c71b003f}


list of particles making up the hose model 



Definition at line 242 of file Solver.h.

\hypertarget{class_solver_a1f6ecbfa472517ff8bb60259dc0bfca7}{
\index{Solver@{Solver}!m\_\-hoseParticlePrototypeList@{m\_\-hoseParticlePrototypeList}}
\index{m\_\-hoseParticlePrototypeList@{m\_\-hoseParticlePrototypeList}!Solver@{Solver}}
\subsubsection[{m\_\-hoseParticlePrototypeList}]{\setlength{\rightskip}{0pt plus 5cm}std::vector$<${\bf FluidParticle}$>$ {\bf Solver::m\_\-hoseParticlePrototypeList}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a1f6ecbfa472517ff8bb60259dc0bfca7}


list of particles, one per fluid that is used as a prototype when creating a hose 



Definition at line 239 of file Solver.h.

\hypertarget{class_solver_acbba3aebcf71f5c2edd68be50bf0650c}{
\index{Solver@{Solver}!m\_\-hoseVelocity@{m\_\-hoseVelocity}}
\index{m\_\-hoseVelocity@{m\_\-hoseVelocity}!Solver@{Solver}}
\subsubsection[{m\_\-hoseVelocity}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Vector {\bf Solver::m\_\-hoseVelocity}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_acbba3aebcf71f5c2edd68be50bf0650c}


the velocity of hose particles 



Definition at line 254 of file Solver.h.

\hypertarget{class_solver_a3679a1060fbf7c40c64abc54317408af}{
\index{Solver@{Solver}!m\_\-hoseWaitUntilHitBoundary@{m\_\-hoseWaitUntilHitBoundary}}
\index{m\_\-hoseWaitUntilHitBoundary@{m\_\-hoseWaitUntilHitBoundary}!Solver@{Solver}}
\subsubsection[{m\_\-hoseWaitUntilHitBoundary}]{\setlength{\rightskip}{0pt plus 5cm}bool {\bf Solver::m\_\-hoseWaitUntilHitBoundary}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a3679a1060fbf7c40c64abc54317408af}


toggles whether the hose particles wait until they first hit the boundary before they act as fluid 



Definition at line 260 of file Solver.h.

\hypertarget{class_solver_a478175bd6c13dacb3599b77eb88dd723}{
\index{Solver@{Solver}!m\_\-hoseWaitUntilHitRBD@{m\_\-hoseWaitUntilHitRBD}}
\index{m\_\-hoseWaitUntilHitRBD@{m\_\-hoseWaitUntilHitRBD}!Solver@{Solver}}
\subsubsection[{m\_\-hoseWaitUntilHitRBD}]{\setlength{\rightskip}{0pt plus 5cm}bool {\bf Solver::m\_\-hoseWaitUntilHitRBD}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a478175bd6c13dacb3599b77eb88dd723}


toggles whether the hose particles wait until they first hit RBDs before they act as fluid 



Definition at line 263 of file Solver.h.

\hypertarget{class_solver_aa2af6362795eeca8486bf47bdae85cdb}{
\index{Solver@{Solver}!m\_\-iteration@{m\_\-iteration}}
\index{m\_\-iteration@{m\_\-iteration}!Solver@{Solver}}
\subsubsection[{m\_\-iteration}]{\setlength{\rightskip}{0pt plus 5cm}int {\bf Solver::m\_\-iteration}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_aa2af6362795eeca8486bf47bdae85cdb}


iteration counter 



Definition at line 266 of file Solver.h.

\hypertarget{class_solver_a6b609b8c74a005f387fadfd748648a2f}{
\index{Solver@{Solver}!m\_\-neighbour@{m\_\-neighbour}}
\index{m\_\-neighbour@{m\_\-neighbour}!Solver@{Solver}}
\subsubsection[{m\_\-neighbour}]{\setlength{\rightskip}{0pt plus 5cm}{\bf Neighbour}$\ast$ {\bf Solver::m\_\-neighbour}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a6b609b8c74a005f387fadfd748648a2f}


the neighbouring structure for the fluid particles 



Definition at line 221 of file Solver.h.

\hypertarget{class_solver_a769da38bdac0dfafcb2c82cef143e30b}{
\index{Solver@{Solver}!m\_\-neighbourForParticleList@{m\_\-neighbourForParticleList}}
\index{m\_\-neighbourForParticleList@{m\_\-neighbourForParticleList}!Solver@{Solver}}
\subsubsection[{m\_\-neighbourForParticleList}]{\setlength{\rightskip}{0pt plus 5cm}std::vector$<${\bf ParticleVector}$>$ {\bf Solver::m\_\-neighbourForParticleList}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a769da38bdac0dfafcb2c82cef143e30b}


the big list of neighbours of each particle 



Definition at line 212 of file Solver.h.

\hypertarget{class_solver_aff683c36e82c4b0afd62454a028c4b36}{
\index{Solver@{Solver}!m\_\-particleList@{m\_\-particleList}}
\index{m\_\-particleList@{m\_\-particleList}!Solver@{Solver}}
\subsubsection[{m\_\-particleList}]{\setlength{\rightskip}{0pt plus 5cm}std::vector$<${\bf FluidParticle}$>$ {\bf Solver::m\_\-particleList}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_aff683c36e82c4b0afd62454a028c4b36}


list of particles making up the fluid simulation 



Definition at line 209 of file Solver.h.

\hypertarget{class_solver_a0b1cb8a50f3a6e98bdb6144d2fead558}{
\index{Solver@{Solver}!m\_\-smoothingLength@{m\_\-smoothingLength}}
\index{m\_\-smoothingLength@{m\_\-smoothingLength}!Solver@{Solver}}
\subsubsection[{m\_\-smoothingLength}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real {\bf Solver::m\_\-smoothingLength}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a0b1cb8a50f3a6e98bdb6144d2fead558}


smoothing kernel length 



Definition at line 215 of file Solver.h.

\hypertarget{class_solver_ac4766e973ca7e0a94836ef19a2dc0ed1}{
\index{Solver@{Solver}!m\_\-weightPoly@{m\_\-weightPoly}}
\index{m\_\-weightPoly@{m\_\-weightPoly}!Solver@{Solver}}
\subsubsection[{m\_\-weightPoly}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real {\bf Solver::m\_\-weightPoly}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_ac4766e973ca7e0a94836ef19a2dc0ed1}


pre-\/calculated part of the poly 6 kernel 



Definition at line 224 of file Solver.h.

\hypertarget{class_solver_a54a080a7d0fcaa85402c731e9204bdb6}{
\index{Solver@{Solver}!m\_\-weightPolyGradient@{m\_\-weightPolyGradient}}
\index{m\_\-weightPolyGradient@{m\_\-weightPolyGradient}!Solver@{Solver}}
\subsubsection[{m\_\-weightPolyGradient}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real {\bf Solver::m\_\-weightPolyGradient}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a54a080a7d0fcaa85402c731e9204bdb6}


pre-\/calculated part of the poly 6 gradient kernel 



Definition at line 227 of file Solver.h.

\hypertarget{class_solver_afd4ec059a18e5a3add5104fa5d12f42f}{
\index{Solver@{Solver}!m\_\-weightPolyLaplacian@{m\_\-weightPolyLaplacian}}
\index{m\_\-weightPolyLaplacian@{m\_\-weightPolyLaplacian}!Solver@{Solver}}
\subsubsection[{m\_\-weightPolyLaplacian}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real {\bf Solver::m\_\-weightPolyLaplacian}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_afd4ec059a18e5a3add5104fa5d12f42f}


pre-\/calculated part of the poly 6 laplacian kernel 



Definition at line 230 of file Solver.h.

\hypertarget{class_solver_a2ac1b25eb8ff28691f84fe5a0503c48d}{
\index{Solver@{Solver}!m\_\-weightPressureGradient@{m\_\-weightPressureGradient}}
\index{m\_\-weightPressureGradient@{m\_\-weightPressureGradient}!Solver@{Solver}}
\subsubsection[{m\_\-weightPressureGradient}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real {\bf Solver::m\_\-weightPressureGradient}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a2ac1b25eb8ff28691f84fe5a0503c48d}


pre-\/calculated part of the pressure gradient kernel 



Definition at line 233 of file Solver.h.

\hypertarget{class_solver_a6c7b46d2a19825efe09f863aec3ed557}{
\index{Solver@{Solver}!m\_\-weightViscosityLaplacian@{m\_\-weightViscosityLaplacian}}
\index{m\_\-weightViscosityLaplacian@{m\_\-weightViscosityLaplacian}!Solver@{Solver}}
\subsubsection[{m\_\-weightViscosityLaplacian}]{\setlength{\rightskip}{0pt plus 5cm}ngl::Real {\bf Solver::m\_\-weightViscosityLaplacian}\hspace{0.3cm}{\ttfamily  \mbox{[}private\mbox{]}}}}
\label{class_solver_a6c7b46d2a19825efe09f863aec3ed557}


pre-\/calculated part of the viscosity laplacian kernel 



Definition at line 236 of file Solver.h.



The documentation for this class was generated from the following files:\begin{DoxyCompactItemize}
\item 
include/\hyperlink{_solver_8h}{Solver.h}\item 
src/\hyperlink{_solver_8cpp}{Solver.cpp}\end{DoxyCompactItemize}
